சாக்கெட் சர்வர் கட்டமைப்புகள்: பைத்தானின் சாக்கெட் சர்வர் தொகுதிக்கான ஒரு நடைமுறை வழிகாட்டி

இன்றைய ஒன்றோடொன்று இணைக்கப்பட்ட உலகில், வெவ்வேறு பயன்பாடுகள் மற்றும் அமைப்புகளுக்கு இடையே தொடர்பை இயக்குவதில் சாக்கெட் நிரலாக்கம் முக்கிய பங்கு வகிக்கிறது. பைத்தானின் SocketServer தொகுதி நெட்வொர்க் சேவையகங்களை உருவாக்க எளிமையான மற்றும் கட்டமைக்கப்பட்ட வழியை வழங்குகிறது, இது அடிப்படையான சிக்கலான தன்மையை நீக்குகிறது. இந்த வழிகாட்டி சாக்கெட் சர்வர் கட்டமைப்புகளின் அடிப்படை கருத்துகள் மூலம் உங்களை அழைத்துச் செல்லும், பைத்தானில் SocketServer தொகுதியின் நடைமுறை பயன்பாடுகளில் கவனம் செலுத்தும். அடிப்படை சர்வர் அமைப்பு, பல வாடிக்கையாளர்களை ஒரே நேரத்தில் கையாளுதல் மற்றும் உங்கள் குறிப்பிட்ட தேவைகளுக்கு சரியான சர்வர் வகையைத் தேர்ந்தெடுப்பது உள்ளிட்ட பல்வேறு அம்சங்களை நாங்கள் உள்ளடக்குவோம். நீங்கள் ஒரு எளிய சாட் பயன்பாட்டை உருவாக்கினாலும் அல்லது ஒரு சிக்கலான விநியோகிக்கப்பட்ட அமைப்பை உருவாக்கினாலும், பைத்தானில் நெட்வொர்க் நிரலாக்கத்தில் தேர்ச்சி பெறுவதற்கு SocketServer ஐப் புரிந்துகொள்வது ஒரு முக்கியமான படியாகும்.

சாக்கெட் சேவையகங்களைப் புரிந்துகொள்வது

ஒரு சாக்கெட் சர்வர் என்பது உள்வரும் கிளையன்ட் இணைப்புகளுக்கு ஒரு குறிப்பிட்ட போர்ட்டில் கேட்கும் ஒரு நிரலாகும். ஒரு கிளையன்ட் இணைக்கும்போது, ​​சர்வர் இணைப்பை ஏற்று தொடர்புகொள்ள ஒரு புதிய சாக்கெட்டை உருவாக்குகிறது. இது சர்வர் ஒரே நேரத்தில் பல வாடிக்கையாளர்களைக் கையாள அனுமதிக்கிறது. பைத்தானில் உள்ள SocketServer தொகுதி இத்தகைய சேவையகங்களை உருவாக்குவதற்கான கட்டமைப்பை வழங்குகிறது, சாக்கெட் மேலாண்மை மற்றும் இணைப்பு கையாளுதலின் குறைந்த-நிலை விவரங்களைக் கையாளுகிறது.

முக்கிய கருத்துகள்

• சாக்கெட்: ஒரு சாக்கெட் என்பது நெட்வொர்க்கில் இயங்கும் இரண்டு நிரல்களுக்கு இடையே இருவழித் தொடர்பு இணைப்பின் இறுதிப்புள்ளியாகும். இது ஒரு தொலைபேசி பலாவுக்கு ஒத்ததாகும் - ஒரு நிரல் தகவலை அனுப்ப ஒரு சாக்கெட்டில் செருகும், மற்றொரு நிரல் அதைப் பெற மற்றொரு சாக்கெட்டில் செருகும்.
• போர்ட்: ஒரு போர்ட் என்பது நெட்வொர்க் இணைப்புகள் தொடங்கி முடியும் ஒரு மெய்நிகர் புள்ளியாகும். இது ஒரு இயந்திரத்தில் இயங்கும் வெவ்வேறு பயன்பாடுகள் அல்லது சேவைகளை வேறுபடுத்தும் ஒரு எண் அடையாளங்காட்டி. உதாரணமாக, HTTP பொதுவாக போர்ட் 80 ஐயும், HTTPS போர்ட் 443 ஐயும் பயன்படுத்துகிறது.
• IP முகவரி: IP (இணைய நெறிமுறை) முகவரி என்பது ஒரு கணினி நெட்வொர்க்குடன் இணைக்கப்பட்ட ஒவ்வொரு சாதனத்திற்கும் ஒதுக்கப்பட்ட ஒரு எண் லேபிள் ஆகும், இது தகவல்தொடர்புக்கு இணைய நெறிமுறையைப் பயன்படுத்துகிறது. இது நெட்வொர்க்கில் சாதனத்தை அடையாளம் காட்டுகிறது, மற்ற சாதனங்கள் அதற்கு தரவை அனுப்ப அனுமதிக்கிறது. IP முகவரிகள் இணையத்தில் உள்ள கணினிகளுக்கான தபால் முகவரிகள் போன்றவை.
• TCP vs. UDP: TCP (டிரான்ஸ்மிஷன் கண்ட்ரோல் புரோட்டோகால்) மற்றும் UDP (யூசர் டேட்டாகிராம் புரோட்டோகால்) ஆகியவை நெட்வொர்க் தகவல்தொடர்புகளில் பயன்படுத்தப்படும் இரண்டு அடிப்படை போக்குவரத்து நெறிமுறைகளாகும். TCP இணைப்பு சார்ந்ததாகும், தரவின் நம்பகமான, வரிசைப்படுத்தப்பட்ட மற்றும் பிழை சரிபார்க்கப்பட்ட விநியோகத்தை வழங்குகிறது. UDP இணைப்பு இல்லாதது, வேகமான ஆனால் குறைந்த நம்பகமான விநியோகத்தை வழங்குகிறது. TCP மற்றும் UDP க்கு இடையிலான தேர்வு பயன்பாட்டின் தேவைகளைப் பொறுத்தது.

பைத்தானின் SocketServer தொகுதியை அறிமுகப்படுத்துகிறோம்

SocketServer தொகுதி அடிப்படையான சாக்கெட் API க்கான உயர்-நிலை இடைமுகத்தை வழங்குவதன் மூலம் பைத்தானில் நெட்வொர்க் சேவையகங்களை உருவாக்கும் செயல்முறையை எளிதாக்குகிறது. சாக்கெட் மேலாண்மையின் பல சிக்கல்களை இது நீக்குகிறது, டெவலப்பர்கள் குறைந்த-நிலை விவரங்களை விட பயன்பாட்டு தர்க்கத்தில் கவனம் செலுத்த அனுமதிக்கிறது. TCP சேவையகங்கள் (TCPServer) மற்றும் UDP சேவையகங்கள் (UDPServer) உட்பட வெவ்வேறு வகையான சேவையகங்களை உருவாக்க பயன்படும் பல வகுப்புகளை தொகுதி வழங்குகிறது.

SocketServer இல் முக்கிய வகுப்புகள்

• BaseServer: SocketServer தொகுதியில் உள்ள அனைத்து சர்வர் வகுப்புகளுக்கும் அடிப்படை வகுப்பு. இது இணைப்புகளைக் கேட்பது மற்றும் கோரிக்கைகளைக் கையாளுவது போன்ற அடிப்படை சர்வர் நடத்தையை வரையறுக்கிறது.
• TCPServer: TCP (டிரான்ஸ்மிஷன் கண்ட்ரோல் புரோட்டோகால்) சேவையகத்தை செயல்படுத்தும் BaseServer இன் துணை வகுப்பு. TCP நம்பகமான, வரிசைப்படுத்தப்பட்ட மற்றும் பிழை சரிபார்க்கப்பட்ட தரவு விநியோகத்தை வழங்குகிறது.
• UDPServer: UDP (யூசர் டேட்டாகிராம் புரோட்டோகால்) சேவையகத்தை செயல்படுத்தும் BaseServer இன் துணை வகுப்பு. UDP இணைப்பு இல்லாதது மற்றும் வேகமான ஆனால் குறைந்த நம்பகமான தரவு பரிமாற்றத்தை வழங்குகிறது.
• BaseRequestHandler: கோரிக்கை கையாளுதல் வகுப்புகளுக்கான அடிப்படை வகுப்பு. ஒரு கோரிக்கை கையாளுபவர் தனிப்பட்ட கிளையன்ட் கோரிக்கைகளைக் கையாளப் பொறுப்பு.
• StreamRequestHandler: TCP கோரிக்கைகளைக் கையாளும் BaseRequestHandler இன் துணை வகுப்பு. இது கிளையன்ட் சாக்கெட்டிற்கு தரவை ஸ்ட்ரீம்களாகப் படிப்பதற்கும் எழுதுவதற்கும் வசதியான முறைகளை வழங்குகிறது.
• DatagramRequestHandler: UDP கோரிக்கைகளைக் கையாளும் BaseRequestHandler இன் துணை வகுப்பு. இது டேட்டாகிராம்களைப் (தரவு பாக்கெட்டுகள்) பெறுவதற்கும் அனுப்புவதற்கும் முறைகளை வழங்குகிறது.

எளிய TCP சேவையகத்தை உருவாக்குதல்

உள்வரும் இணைப்புகளைக் கேட்டு, பெறப்பட்ட தரவை கிளையன்ட்டிற்குத் திருப்பி அனுப்பும் எளிய TCP சேவையகத்தை உருவாக்குவதன் மூலம் ஆரம்பிக்கலாம். இந்த எடுத்துக்காட்டு ஒரு SocketServer பயன்பாட்டின் அடிப்படை கட்டமைப்பைக் காட்டுகிறது.

எடுத்துக்காட்டு: எக்கோ சர்வர்

ஒரு அடிப்படை எக்கோ சர்வருக்கான குறியீடு இங்கே:

            import SocketServer

class MyTCPHandler(SocketServer.BaseRequestHandler):
    """
    The request handler class for our server.

    It is instantiated once per connection to the server, and must
    override the handle() method to implement communication to the
    client.
    """

    def handle(self):
        # self.request is the TCP socket connected to the client
        self.data = self.request.recv(1024).strip()
        print "{} wrote:".format(self.client_address[0])
        print self.data
        # just send back the same data you received.
        self.request.sendall(self.data)

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999

    # Create the server, binding to localhost on port 9999
    server = SocketServer.TCPServer((HOST, PORT), MyTCPHandler)

    # Activate the server; this will keep running until you
    # interrupt the program with Ctrl-C
    server.serve_forever()

            

              
                Copy
              
            
          

விளக்கம்:

• நாங்கள் SocketServer தொகுதியை இறக்குமதி செய்கிறோம்.
• SocketServer.BaseRequestHandler இலிருந்து மரபுரிமையாக வரும் MyTCPHandler என்ற கோரிக்கை கையாளுதல் வகுப்பை நாங்கள் வரையறுக்கிறோம்.
• handle() முறை கோரிக்கை கையாளுதலின் மையமாகும். ஒரு கிளையன்ட் சர்வருடன் இணைக்கும் போதெல்லாம் இது அழைக்கப்படுகிறது.
• handle() முறைக்குள், self.request.recv(1024) ஐப் பயன்படுத்தி கிளையன்டிடமிருந்து தரவைப் பெறுகிறோம். இந்த எடுத்துக்காட்டில் பெறப்பட்ட அதிகபட்ச தரவை 1024 பைட்களாகக் கட்டுப்படுத்துகிறோம்.
• கிளையண்டின் முகவரி மற்றும் பெறப்பட்ட தரவை கன்சோலுக்கு அச்சிடுகிறோம்.
• self.request.sendall(self.data) ஐப் பயன்படுத்தி பெறப்பட்ட தரவை கிளையன்ட்டிற்குத் திருப்பி அனுப்புகிறோம்.
• if __name__ == "__main__": தொகுதியில், TCPServer நிகழ்வை உருவாக்குகிறோம், அதை லோக்கல் ஹோஸ்ட் முகவரி மற்றும் போர்ட் 9999 க்கு பைண்டிங் செய்கிறோம்.
• பின்னர் சர்வரைத் தொடங்க server.serve_forever() ஐ அழைக்கிறோம், மேலும் நிரல் குறுக்கிடப்படும் வரை அதை இயங்க வைக்கிறோம்.

எக்கோ சர்வரை இயக்குதல்

எக்கோ சர்வரை இயக்க, குறியீட்டை ஒரு கோப்பில் (எ.கா., echo_server.py) சேமித்து, கட்டளை வரியிலிருந்து இயக்கவும்:

            python echo_server.py
            

              
                Copy
              
            
          

சர்வர் போர்ட் 9999 இல் இணைப்புகளுக்குக் கேட்கத் தொடங்கும். பின்னர் நீங்கள் telnet அல்லது netcat போன்ற கிளையன்ட் நிரலைப் பயன்படுத்தி சர்வருடன் இணைக்கலாம். உதாரணமாக, netcat ஐப் பயன்படுத்துதல்:

            nc localhost 9999
            

              
                Copy
              
            
          

netcat கிளையண்டில் நீங்கள் தட்டச்சு செய்யும் அனைத்தும் சர்வருக்கு அனுப்பப்பட்டு உங்களுக்குத் திருப்பி அனுப்பப்படும்.

ஒரே நேரத்தில் பல வாடிக்கையாளர்களைக் கையாளுதல்

த்ரெடிங்

த்ரெடிங் ஒரே நேரத்தில் பல வாடிக்கையாளர்களை ஒரே செயல்முறைக்குள் கையாள அனுமதிக்கிறது. ஒவ்வொரு கிளையன்ட் இணைப்பும் தனி த்ரெட்டில் கையாளப்படுகிறது, மற்ற கிளையன்ட்கள் சேவை செய்யப்படும்போது புதிய இணைப்புகளைக் கேட்க சர்வர் தொடர்ந்து அனுமதிக்கிறது. SocketServer தொகுதி ThreadingMixIn வகுப்பை வழங்குகிறது, இது த்ரெடிங்கை இயக்க சர்வர் வகுப்புடன் கலக்கப்படலாம்.

எடுத்துக்காட்டு: த்ரெடட் எக்கோ சர்வர்

            import SocketServer
import threading

class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        data = self.request.recv(1024)
        cur_thread = threading.current_thread()
        response = "{}: {}".format(cur_thread.name, data)
        self.request.sendall(response)

class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
    pass

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999

    server = ThreadedTCPServer((HOST, PORT), ThreadedTCPRequestHandler)
    ip, port = server.server_address

    # Start a thread with the server -- that thread will then start one
    # more thread for each request
    server_thread = threading.Thread(target=server.serve_forever)
    # Exit the server thread when the main thread terminates
    server_thread.daemon = True
    server_thread.start()

    print "Server loop running in thread:", server_thread.name

    # ... (Your main thread logic here, e.g., simulating client connections)
    # For example, to keep the main thread alive:
    # while True:
    #     pass # Or perform other tasks

    server.shutdown()

            

              
                Copy
              
            
          

விளக்கம்:

• நாங்கள் threading தொகுதியை இறக்குமதி செய்கிறோம்.
• SocketServer.BaseRequestHandler இலிருந்து மரபுரிமையாக வரும் ThreadedTCPRequestHandler வகுப்பை உருவாக்குகிறோம். handle() முறை முந்தைய எடுத்துக்காட்டைப் போன்றது, ஆனால் பதிலில் தற்போதைய த்ரெட்டின் பெயரையும் உள்ளடக்கியது.
• SocketServer.ThreadingMixIn மற்றும் SocketServer.TCPServer ஆகிய இரண்டிலிருந்தும் மரபுரிமையாக வரும் ThreadedTCPServer வகுப்பை உருவாக்குகிறோம். இந்த கலவை சர்வருக்கான த்ரெடிங்கை இயக்குகிறது.
• if __name__ == "__main__": தொகுதியில், ThreadedTCPServer நிகழ்வை உருவாக்குகிறோம், மேலும் அதை ஒரு தனி த்ரெட்டில் தொடங்குகிறோம். சர்வர் பின்னணியில் இயங்கும் போது இது முக்கிய த்ரெட்டை தொடர்ந்து இயக்க அனுமதிக்கிறது.

இந்த சர்வர் இப்போது ஒரே நேரத்தில் பல கிளையன்ட் இணைப்புகளைக் கையாள முடியும். ஒவ்வொரு இணைப்பும் தனி த்ரெட்டில் கையாளப்படும், சர்வர் ஒரே நேரத்தில் பல வாடிக்கையாளர்களுக்கு பதிலளிக்க அனுமதிக்கிறது.

ஃபோர்க்கிங்

ஒரே நேரத்தில் பல வாடிக்கையாளர்களைக் கையாள ஃபோர்க்கிங் மற்றொரு வழியாகும். ஒரு புதிய கிளையன்ட் இணைப்பு பெறப்படும்போது, ​​இணைப்பைக் கையாள சர்வர் ஒரு புதிய செயல்முறையை ஃபோர்க் செய்கிறது. ஒவ்வொரு செயல்முறைக்கும் அதன் சொந்த நினைவக இடம் உள்ளது, எனவே செயல்முறைகள் ஒன்றுக்கொன்று தனிமைப்படுத்தப்படுகின்றன. SocketServer தொகுதி ForkingMixIn வகுப்பை வழங்குகிறது, இது ஃபோர்க்கிங்கை இயக்க சர்வர் வகுப்புடன் கலக்கப்படலாம். குறிப்பு: ஃபோர்க்கிங் பொதுவாக யுனிக்ஸ் போன்ற அமைப்புகளில் (லினக்ஸ், macOS) பயன்படுத்தப்படுகிறது மற்றும் விண்டோஸ் சூழல்களுக்கு கிடைக்காமல் போகலாம் அல்லது பொருத்தமானதாக இருக்காது.

எடுத்துக்காட்டு: ஃபோர்க்கிங் எக்கோ சர்வர்

            import SocketServer
import os

class ForkingTCPRequestHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        data = self.request.recv(1024)
        pid = os.getpid()
        response = "PID {}: {}".format(pid, data)
        self.request.sendall(response)

class ForkingTCPServer(SocketServer.ForkingMixIn, SocketServer.TCPServer):
    pass

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999

    server = ForkingTCPServer((HOST, PORT), ForkingTCPRequestHandler)
    ip, port = server.server_address

    server.serve_forever()

            

              
                Copy
              
            
          

விளக்கம்:

• நாங்கள் os தொகுதியை இறக்குமதி செய்கிறோம்.
• SocketServer.BaseRequestHandler இலிருந்து மரபுரிமையாக வரும் ForkingTCPRequestHandler வகுப்பை உருவாக்குகிறோம். handle() முறை பதிலில் செயல்முறை ஐடி (PID) ஐ உள்ளடக்கியது.
• SocketServer.ForkingMixIn மற்றும் SocketServer.TCPServer ஆகிய இரண்டிலிருந்தும் மரபுரிமையாக வரும் ForkingTCPServer வகுப்பை உருவாக்குகிறோம். இந்த கலவை சர்வருக்கான ஃபோர்க்கிங்கை இயக்குகிறது.
• if __name__ == "__main__": தொகுதியில், ForkingTCPServer நிகழ்வை உருவாக்கி server.serve_forever() ஐப் பயன்படுத்தி தொடங்குகிறோம். ஒவ்வொரு கிளையன்ட் இணைப்பும் ஒரு தனி செயல்பாட்டில் கையாளப்படும்.

ஒரு கிளையன்ட் இந்த சர்வருடன் இணைக்கும்போது, ​​சர்வர் இணைப்பைக் கையாள ஒரு புதிய செயல்முறையை ஃபோர்க் செய்யும். ஒவ்வொரு செயல்முறைக்கும் அதன் சொந்த PID இருக்கும், இணைப்புகள் வெவ்வேறு செயல்முறைகளால் கையாளப்படுகின்றன என்பதை நீங்கள் காண அனுமதிக்கிறது.

த்ரெடிங் மற்றும் ஃபோர்க்கிங் இடையே தேர்வு செய்தல்

த்ரெடிங் மற்றும் ஃபோர்க்கிங் இடையே உள்ள தேர்வு இயக்க முறைமை, பயன்பாட்டின் தன்மை மற்றும் கிடைக்கக்கூடிய வளங்கள் உள்ளிட்ட பல காரணிகளைப் பொறுத்தது. முக்கிய கருத்தில் கொள்ள வேண்டியவற்றின் சுருக்கம் இங்கே:

• இயக்க முறைமை: யுனிக்ஸ் போன்ற அமைப்புகளில் ஃபோர்க்கிங் பொதுவாக விரும்பப்படுகிறது, விண்டோஸில் த்ரெடிங் மிகவும் பொதுவானது.
• வள நுகர்வு: ஒவ்வொரு செயல்முறைக்கும் அதன் சொந்த நினைவக இடம் இருப்பதால் ஃபோர்க்கிங் த்ரெடிங்கை விட அதிகமான வளங்களை உட்கொள்கிறது. த்ரெடிங் நினைவக இடத்தைப் பகிர்ந்துகொள்கிறது, இது மிகவும் திறமையானதாக இருக்கும், ஆனால் பந்தய நிலைமைகளைத் தவிர்க்க கவனமாக ஒத்திசைவு தேவைப்படுகிறது.
• சிக்கலானது: குறிப்பாக பகிரப்பட்ட வளங்களைக் கையாளும் போது, ​​ஃபோர்க்கிங்கை விட த்ரெடிங்கை செயல்படுத்துவதும் பிழைத்திருத்தமும் மிகவும் சிக்கலானதாக இருக்கலாம்.
• அளவிடுதல்: சில சந்தர்ப்பங்களில் த்ரெடிங்கை விட ஃபோர்க்கிங் சிறப்பாக அளவிட முடியும், ஏனெனில் இது பல CPU கோர்களை மிகவும் திறம்பட பயன்படுத்த முடியும். இருப்பினும், செயல்முறைகளை உருவாக்குதல் மற்றும் நிர்வகிப்பதன் மேல்நிலை அளவிடுதலை கட்டுப்படுத்தலாம்.

பொதுவாக, நீங்கள் யுனிக்ஸ் போன்ற அமைப்பில் எளிய பயன்பாட்டை உருவாக்கினால், ஃபோர்க்கிங் ஒரு நல்ல தேர்வாக இருக்கலாம். நீங்கள் மிகவும் சிக்கலான பயன்பாட்டை உருவாக்கினால் அல்லது விண்டோஸை இலக்காகக் கொண்டிருந்தால், த்ரெடிங் மிகவும் பொருத்தமானதாக இருக்கலாம். உங்கள் சூழலின் வளக் கட்டுப்பாடுகள் மற்றும் உங்கள் பயன்பாட்டின் சாத்தியமான அளவிடுதல் தேவைகளையும் கருத்தில் கொள்வது முக்கியம். அதிக அளவிலான பயன்பாடுகளுக்கு, `asyncio` போன்ற ஒத்திசைவற்ற கட்டமைப்புகளைக் கவனியுங்கள், அவை சிறந்த செயல்திறன் மற்றும் வள பயன்பாட்டை வழங்க முடியும்.

எளிய UDP சேவையகத்தை உருவாக்குதல்

UDP (யூசர் டேட்டாகிராம் புரோட்டோகால்) என்பது இணைப்பு இல்லாத நெறிமுறையாகும், இது TCP ஐ விட வேகமான ஆனால் குறைந்த நம்பகமான தரவு பரிமாற்றத்தை வழங்குகிறது. வேகமான ஸ்ட்ரீமிங் மீடியா மற்றும் ஆன்லைன் கேம்கள் போன்ற நம்பகத்தன்மையை விட வேகம் மிக முக்கியமான பயன்பாடுகளுக்கு UDP பெரும்பாலும் பயன்படுத்தப்படுகிறது. UDP சேவையகங்களை உருவாக்குவதற்கு SocketServer தொகுதி UDPServer வகுப்பை வழங்குகிறது.

எடுத்துக்காட்டு: UDP எக்கோ சர்வர்

            import SocketServer

class MyUDPHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        data = self.request[0].strip()
        socket = self.request[1]
        print "{} wrote:".format(self.client_address[0])
        print data
        socket.sendto(data, self.client_address)

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999

    server = SocketServer.UDPServer((HOST, PORT), MyUDPHandler)

    server.serve_forever()

            

              
                Copy
              
            
          

விளக்கம்:

• MyUDPHandler வகுப்பில் உள்ள handle() முறை கிளையன்டிடமிருந்து தரவைப் பெறுகிறது. TCP போலல்லாமல், UDP தரவு டேட்டாகிராம் (தரவு பாக்கெட்) ஆகப் பெறப்படுகிறது.
• self.request பண்புக்கூறு தரவு மற்றும் சாக்கெட்டைக் கொண்ட ஒரு tuple ஆகும். self.request[0] ஐப் பயன்படுத்தி தரவையும், self.request[1] ஐப் பயன்படுத்தி சாக்கெட்டையும் பிரித்தெடுக்கிறோம்.
• socket.sendto(data, self.client_address) ஐப் பயன்படுத்தி பெறப்பட்ட தரவை கிளையன்ட்டிற்குத் திருப்பி அனுப்புகிறோம்.

இந்த சர்வர் வாடிக்கையாளர்களிடமிருந்து UDP டேட்டாகிராம்களைப் பெற்று அவற்றை அனுப்புபவருக்குத் திருப்பி அனுப்பும்.

மேம்பட்ட நுட்பங்கள்

வெவ்வேறு தரவு வடிவங்களைக் கையாளுதல்

பல நிஜ உலக பயன்பாடுகளில், JSON, XML அல்லது புரோட்டோகால் பஃபர்ஸ் போன்ற வெவ்வேறு தரவு வடிவங்களைக் கையாள வேண்டும். பைத்தானின் உள்ளமைக்கப்பட்ட தொகுதிகள் அல்லது மூன்றாம் தரப்பு நூலகங்களைப் பயன்படுத்தி தரவை வரிசைப்படுத்தலாம். உதாரணமாக, JSON தரவைக் கையாள json தொகுதியைப் பயன்படுத்தலாம்:

            import SocketServer
import json

class JSONTCPHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        try:
            data = self.request.recv(1024).strip()
            json_data = json.loads(data)
            print "Received JSON data:", json_data

            # Process the JSON data
            response_data = {"status": "success", "message": "Data received"}
            response_json = json.dumps(response_data)
            self.request.sendall(response_json)

        except ValueError as e:
            print "Invalid JSON data received: {}".format(e)
            self.request.sendall(json.dumps({"status": "error", "message": "Invalid JSON"}))

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999

    server = SocketServer.TCPServer((HOST, PORT), JSONTCPHandler)
    server.serve_forever()

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டு கிளையன்டிடமிருந்து JSON தரவைப் பெறுகிறது, அதை json.loads() ஐப் பயன்படுத்தி பாகுபடுத்துகிறது, அதை செயலாக்குகிறது, மேலும் json.dumps() ஐப் பயன்படுத்தி ஒரு JSON பதிலை கிளையன்ட்டிற்குத் திருப்பி அனுப்புகிறது. தவறான JSON தரவைப் பிடிக்க பிழை கையாளுதல் சேர்க்கப்பட்டுள்ளது.

அங்கீகாரத்தை செயல்படுத்துதல்

பாதுகாப்பான பயன்பாடுகளுக்கு, வாடிக்கையாளர்களின் அடையாளத்தை சரிபார்க்க அங்கீகாரத்தை செயல்படுத்த வேண்டும். பயனர் பெயர்/கடவுச்சொல் அங்கீகாரம், API விசைகள் அல்லது டிஜிட்டல் சான்றிதழ்கள் போன்ற பல்வேறு முறைகளைப் பயன்படுத்தி இதைச் செய்யலாம். பயனர் பெயர்/கடவுச்சொல் அங்கீகாரத்தின் எளிமைப்படுத்தப்பட்ட எடுத்துக்காட்டு இங்கே:

            import SocketServer
import hashlib

# Replace with a secure way to store passwords (e.g., using bcrypt)
USER_CREDENTIALS = {
    "user1": "password123",
    "user2": "secure_password"
}

class AuthTCPHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        # Authentication logic
        username = self.request.recv(1024).strip()
        password = self.request.recv(1024).strip()

        if username in USER_CREDENTIALS and USER_CREDENTIALS[username] == password:
            print "User {} authenticated successfully".format(username)
            self.request.sendall("Authentication successful")
            # Proceed with handling the client request
            # (e.g., receive further data and process it)

        else:
            print "Authentication failed for user {}".format(username)
            self.request.sendall("Authentication failed")

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999

    server = SocketServer.TCPServer((HOST, PORT), AuthTCPHandler)
    server.serve_forever()

            

              
                Copy
              
            
          

முக்கிய பாதுகாப்பு குறிப்பு: மேலே உள்ள எடுத்துக்காட்டு விளக்க நோக்கங்களுக்காக மட்டுமே மற்றும் பாதுகாப்பானது அல்ல. கடவுச்சொற்களை ஒருபோதும் வெற்று உரையாக சேமிக்க வேண்டாம். அவற்றை சேமிக்கும் முன் கடவுச்சொற்களை ஹாஷ் செய்ய bcrypt அல்லது Argon2 போன்ற வலுவான கடவுச்சொல் ஹாஷிங் வழிமுறையைப் பயன்படுத்தவும். கூடுதலாக, உற்பத்திச் சூழல்களுக்கு OAuth 2.0 அல்லது JWT (JSON வெப் டோக்கன்கள்) போன்ற மிகவும் வலுவான அங்கீகார பொறிமுறையைப் பயன்படுத்துவதைக் கவனியுங்கள்.

பதிவு செய்தல் மற்றும் பிழை கையாளுதல்

உங்கள் சர்வரை பிழைத்திருத்தம் செய்து பராமரிக்க சரியான பதிவு செய்தல் மற்றும் பிழை கையாளுதல் அவசியம். நிகழ்வுகள், பிழைகள் மற்றும் பிற தொடர்புடைய தகவல்களைப் பதிவு செய்ய பைத்தானின் logging தொகுதியைப் பயன்படுத்தவும். விதிவிலக்குகளை கருணையுடன் கையாளவும், சர்வர் செயலிழப்பதைத் தடுக்கவும் விரிவான பிழை கையாளுதலை செயல்படுத்தவும். சிக்கல்களை திறம்பட கண்டறிய எப்போதும் போதுமான தகவல்களைப் பதிவு செய்யுங்கள்.

            import SocketServer
import logging

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

class LoggingTCPHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        try:
            data = self.request.recv(1024).strip()
            logging.info("Received data from {}: {}".format(self.client_address[0], data))
            self.request.sendall(data)
        except Exception as e:
            logging.exception("Error handling request from {}: {}".format(self.client_address[0], e))
            self.request.sendall("Error processing request")

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999

    server = SocketServer.TCPServer((HOST, PORT), LoggingTCPHandler)
    server.serve_forever()

            

              
                Copy
              
            
          

உள்வரும் கோரிக்கைகள் மற்றும் கோரிக்கை கையாளுதலின் போது ஏற்படும் பிழைகள் பற்றிய தகவல்களைப் பதிவு செய்ய இந்த எடுத்துக்காட்டு பதிவு செய்தலை உள்ளமைக்கிறது. பிழைத்திருத்தத்திற்கு உதவியாக இருக்கும் முழு ஸ்டாக் ட்ரேஸுடன் விதிவிலக்குகளைப் பதிவு செய்ய logging.exception() முறை பயன்படுத்தப்படுகிறது.

SocketServer க்கு மாற்றுகள்

சாக்கெட் நிரலாக்கத்தைப் பற்றி அறிந்துகொள்ள SocketServer தொகுதி ஒரு நல்ல தொடக்க புள்ளியாக இருந்தாலும், குறிப்பாக உயர் செயல்திறன் மற்றும் அளவிடக்கூடிய பயன்பாடுகளுக்கு சில வரம்புகள் உள்ளன. சில பிரபலமான மாற்றுகளில் பின்வருவன அடங்கும்:

• asyncio: பைத்தானின் உள்ளமைக்கப்பட்ட ஒத்திசைவற்ற I/O கட்டமைப்பு. கொருட்டீன்கள் மற்றும் நிகழ்வு சுழல்களைப் பயன்படுத்தி ஒரே நேரத்தில் பல இணைப்புகளைக் கையாள asyncio மிகவும் திறமையான வழியை வழங்குகிறது. அதிக இணக்கத் தன்மை தேவைப்படும் நவீன பயன்பாடுகளுக்கு இது பொதுவாக விரும்பப்படுகிறது.
• Twisted: பைத்தானில் எழுதப்பட்ட நிகழ்வு அடிப்படையிலான நெட்வொர்க்கிங் எஞ்சின். ட்விஸ்டட் பல்வேறு நெறிமுறைகள் மற்றும் இணக்கத்தன்மை மாதிரிகளுக்கான ஆதரவு உட்பட நெட்வொர்க் பயன்பாடுகளை உருவாக்குவதற்கான பணக்கார அம்சங்களை வழங்குகிறது.
• Tornado: பைத்தான் வலை கட்டமைப்பு மற்றும் ஒத்திசைவற்ற நெட்வொர்க்கிங் நூலகம். டொர்னாடோ அதிக எண்ணிக்கையிலான ஒரே நேரத்தில் இணைப்புகளைக் கையாள வடிவமைக்கப்பட்டுள்ளது மற்றும் பெரும்பாலும் நிகழ்நேர வலை பயன்பாடுகளை உருவாக்கப் பயன்படுகிறது.
• ZeroMQ: உயர் செயல்திறன் ஒத்திசைவற்ற செய்தி நூலகம். விநியோகிக்கப்பட்ட அமைப்புகள் மற்றும் செய்தி வரிசைகளை உருவாக்க ZeroMQ ஒரு எளிய மற்றும் திறமையான வழியை வழங்குகிறது.

முடிவுரை

பைத்தானின் SocketServer தொகுதி நெட்வொர்க் நிரலாக்கத்திற்கு ஒரு மதிப்புமிக்க அறிமுகத்தை வழங்குகிறது, இது ஒப்பீட்டளவில் எளிதாக அடிப்படை சாக்கெட் சேவையகங்களை உருவாக்க உங்களை அனுமதிக்கிறது. சாக்கெட்டுகள், TCP/UDP நெறிமுறைகள் மற்றும் SocketServer பயன்பாடுகளின் கட்டமைப்பு ஆகியவற்றின் முக்கிய கருத்துக்களைப் புரிந்துகொள்வது நெட்வொர்க் அடிப்படையிலான பயன்பாடுகளை உருவாக்குவதற்கு முக்கியமானது. SocketServer அனைத்து சூழ்நிலைகளுக்கும் குறிப்பாக அதிக அளவிடுதல் அல்லது செயல்திறன் தேவைப்படுபவர்களுக்கு ஏற்றதாக இல்லாவிட்டாலும், இது மிகவும் மேம்பட்ட நெட்வொர்க்கிங் நுட்பங்களைக் கற்றுக் கொள்ளவும் asyncio, Twisted மற்றும் Tornado போன்ற மாற்று கட்டமைப்புகளை ஆராயவும் ஒரு வலுவான அடித்தளமாக செயல்படுகிறது. இந்த வழிகாட்டியில் கோடிட்டுக் காட்டப்பட்டுள்ள கோட்பாடுகளைக் கற்றுக்கொள்வதன் மூலம், நெட்வொர்க் நிரலாக்க சவால்களை எதிர்கொள்ள நீங்கள் நன்கு தயாராக இருப்பீர்கள்.

சர்வதேச பரிசீலனைகள்

உலகளாவிய பார்வையாளர்களுக்கான சாக்கெட் சர்வர் பயன்பாடுகளை உருவாக்கும்போது, ​​பின்வரும் சர்வதேசமயமாக்கல் (i18n) மற்றும் மொழிபெயர்ப்பு (l10n) காரணிகளைக் கருத்தில் கொள்வது முக்கியம்:

• எழுத்து குறியாக்கம்: வெவ்வேறு மொழிகளிலிருந்து உரைத் தரவைக் கையாளுவதற்கு, உங்கள் சர்வர் UTF-8 போன்ற பல்வேறு எழுத்து குறியாக்கங்களை ஆதரிக்கிறதா என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள். உள்நாட்டில் யூனிகோடைப் பயன்படுத்தவும், வாடிக்கையாளர்களுக்குத் தரவை அனுப்பும்போது பொருத்தமான குறியாக்கத்திற்கு மாற்றவும்.
• நேர மண்டலங்கள்: நேர முத்திரைகளைக் கையாளும்போதும் நிகழ்வுகளைத் திட்டமிடும்போதும் நேர மண்டலங்களைக் கருத்தில் கொள்ளுங்கள். வெவ்வேறு நேர மண்டலங்களுக்கு இடையில் மாற்ற pytz போன்ற நேர மண்டலம் அறிந்த நூலகத்தைப் பயன்படுத்தவும்.
• எண் மற்றும் தேதி வடிவமைத்தல்: வெவ்வேறு பிராந்தியங்களுக்கு சரியான வடிவத்தில் எண்களையும் தேதிகளையும் காண்பிக்க லோக்கேல் சார்ந்த வடிவமைப்பைப் பயன்படுத்தவும். பைத்தானின் locale தொகுதியை இந்த நோக்கத்திற்காகப் பயன்படுத்தலாம்.
• மொழிபெயர்ப்பு: பரந்த பார்வையாளர்களுக்கு அணுகக்கூடியதாக இருக்க உங்கள் சர்வரின் செய்திகள் மற்றும் பயனர் இடைமுகத்தை வெவ்வேறு மொழிகளில் மொழிபெயர்க்கவும்.
• நாணயத்தைக் கையாளுதல்: நிதி பரிவர்த்தனைகளைக் கையாளும் போது, ​​உங்கள் சர்வர் வெவ்வேறு நாணயங்களை ஆதரிக்கிறதா என்பதையும் சரியான மாற்று விகிதங்களைப் பயன்படுத்துகிறதா என்பதையும் உறுதிப்படுத்திக் கொள்ளுங்கள்.
• சட்ட மற்றும் ஒழுங்குமுறை இணக்கம்: வெவ்வேறு நாடுகளில் உங்கள் சர்வரின் செயல்பாடுகளுக்கு பொருந்தக்கூடிய எந்தவொரு சட்ட அல்லது ஒழுங்குமுறை தேவைகளையும் அறிந்து கொள்ளுங்கள், அதாவது தரவு தனியுரிமை சட்டங்கள் (எ.கா., GDPR).

இந்த சர்வதேச பரிசீலனைகளை நிவர்த்தி செய்வதன் மூலம், உலகளாவிய பார்வையாளர்களுக்கு அணுகக்கூடிய மற்றும் பயனர் நட்புடைய சாக்கெட் சர்வர் பயன்பாடுகளை நீங்கள் உருவாக்க முடியும்.